Usenet 1993 July/InfoMagic USENET CD-ROM July 1993.ISO/sources/unix/volume14/cdecl2/part02

Internet Message Format | 1988-05-09 | 27.4 KB

Subject:  v14i091:  New version of Cdecl, parse C declarations, Part02/02
Newsgroups: comp.sources.unix
Sender: sources
Approved: [e-mail]

Submitted-by: cbosgd!pegasus!hansen (Tony Hansen)
Posting-number: Volume 14, Issue 91
Archive-name: cdecl2/part02

#! /bin/sh
# This is a shell archive.  Remove anything before this line, then unpack
# it by saving it into a file and typing "sh file".  To overwrite existing
# files, type "sh file -c".  You can also feed this as standard input via
# unshar, or by typing "sh <file", e.g..  If this archive is complete, you
# will see the following message at the end:
#        "End of archive 2 (of 2)."
# Contents:  cdecl.c
# Wrapped by [e-mail] on Mon May  9 20:40:48 1988
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f 'cdecl.c' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'cdecl.c'\"
else
echo shar: Extracting \"'cdecl.c'\" \(25555 characters\)
sed "s/^X//" >'cdecl.c' <<'END_OF_FILE'
X/*
X * cdecl - ANSI C and C++ declaration composer & decoder
X *
X *    originally written
X *        Graham Ross
X *        once at tektronix!tekmdp!grahamr
X *        now at Context, Inc.
X *
X *    modified to provide hints for unsupported types
X *    added argument lists for functions
X *    added 'explain cast' grammar
X *    added #ifdef for 'create program' feature
X *        ???? (sorry, I lost your name and login)
X *
X *    conversion to ANSI C
X *        David Wolverton
X *        ihnp4!houxs!daw
X *
X *    merged D. Wolverton's ANSI C version w/ ????'s version
X *    added function prototypes
X *    added C++ declarations
X *    made type combination checking table driven
X *    added checks for void variable combinations
X *    made 'create program' feature a runtime option
X *    added file parsing as well as just stdin
X *    added help message at beginning
X *    added prompts when on a TTY or in interactive mode
X *    added getopt() usage
X *    added -a, -r, -p, -c, -d, -D, -V, -i and -+ options
X *    delinted
X *    added #defines for those without getopt or void
X *    added 'set options' command
X *    added 'quit/exit' command
X *    added synonyms
X *        Tony Hansen
X *        attmail!tony, ihnp4!pegasus!hansen
X *
X *    added extern, register, static
X *    added links to explain, cast, declare
X *    separately developed ANSI C support
X *        Merlyn LeRoy
X *        [e-mail]
X *
X *    merged versions from LeRoy
X *    added tmpfile() support
X *    allow more parts to be missing during explanations
X *        Tony Hansen
X *        attmail!tony, ihnp4!pegasus!hansen
X */
X
char cdeclsccsid[] = "@(#)cdecl.c    2.4 3/31/88";
X
X#include <stdio.h>
X#include <ctype.h>
X#if __STDC__ || defined(DOS)
X# include <stdlib.h>
X# include <stddef.h>
X# include <string.h>
X# include <stdarg.h>
X#else
X# ifndef NOVARARGS
X#  include <varargs.h>
X# endif /* ndef NOVARARGS */
char *malloc();
void free(), exit(), perror();
X# ifdef BSD
X#  include <strings.h>
X   extern int errno;
X#  define strrchr rindex
X#  define NOTMPFILE
X# else
X#  include <string.h>
X#  include <errno.h>
X# endif /* BSD */
X# ifdef NOVOID
X#  define void int
X# endif /* NOVOID */
X#endif /* __STDC__ || DOS */
X
X#define    MB_SHORT    0001
X#define    MB_LONG        0002
X#define    MB_UNSIGNED    0004
X#define MB_INT        0010
X#define MB_CHAR        0020
X#define MB_FLOAT    0040
X#define MB_DOUBLE    0100
X#define MB_VOID        0200
X#define    MB_SIGNED    0400
X
X#define NullCP ((char*)NULL)
X#ifdef dodebug
X# define Debug(x) do { if (DebugFlag) (void) fprintf x; } while (0)
X#else
X# define Debug(x) /* nothing */
X#endif
X
X#if __STDC__
X  char *ds(char *), *cat(char *, ...), *visible(int);
X  int getopt(int,char **,char *);
X  int main(int, char **);
X  int yywrap(void);
X  int dostdin(void);
X  void mbcheck(void), dohelp(void), usage(void);
X  void prompt(void), doprompt(void), noprompt(void);
X  void unsupp(char *, char *);
X  void notsupported(char *, char *, char *);
X  void yyerror(char *);
X  void doset(char *);
X  void dodeclare(char*, char*, char*, char*, char*);
X  void docast(char*, char*, char*, char*);
X  void dodexplain(char*, char*, char*, char*);
X  void docexplain(char*, char*, char*, char*);
X  void setprogname(char *);
X  int dotmpfile(int, char**), dofileargs(int, char**);
X#else
X  char *ds(), *cat(), *visible();
X  int getopt();
X  void mbcheck(), dohelp(), usage();
X  void prompt(), doprompt(), noprompt();
X  void unsupp(), notsupported();
X  void yyerror();
X  void doset(), dodeclare(), docast(), dodexplain(), docexplain();
X  void setprogname();
X  int dotmpfile(), dofileargs();
X#endif /* __STDC__ */
X  FILE *tmpfile();
X
X/* variables used during parsing */
unsigned modbits = 0;
int arbdims = 1;
char *savedname = 0;
char unknown_name[] = "unknown_name";
char prev = 0;        /* the current type of the variable being examined */
X            /*    values    type                   */
X            /*    p    pointer                   */
X            /*    r    reference               */
X            /*    f    function               */
X            /*    a    array (of arbitrary dimensions)    */
X            /*    A    array with dimensions           */
X            /*    n    name                   */
X            /*    v    void                   */
X            /*    s    struct | class               */
X            /*    t    simple type (int, long, etc.)       */
X
X/* options */
int RitchieFlag = 0;        /* -r, assume Ritchie PDP C language */
int MkProgramFlag = 0;        /* -c, output {} and ; after declarations */
int PreANSIFlag = 0;        /* -p, assume pre-ANSI C language */
int CplusplusFlag = 0;        /* -+, assume C++ language */
int OnATty = 0;            /* stdin is coming from a terminal */
int Interactive = 0;        /* -i, overrides OnATty */
int KeywordName = 0;        /* $0 is a keyword (declare, explain, cast) */
char *progname = "cdecl";    /* $0 */
X
X#if dodebug
int DebugFlag = 0;        /* -d, output debugging trace info */
X#endif
X
X#ifdef doyydebug        /* compile in yacc trace statements */
X#define YYDEBUG 1
X#endif /* doyydebug */
X
X#include "cdgram.c"
X#include "cdlex.c"
X
X/* definitions (and abbreviations) for type combinations cross check table */
X#define ALWAYS    0    /* combo always okay */
X#define _    ALWAYS
X#define NEVER    1    /* combo never allowed */
X#define X    NEVER
X#define RITCHIE    2    /* combo not allowed in Ritchie compiler */
X#define R    RITCHIE
X#define PREANSI    3    /* combo not allowed in Pre-ANSI compiler */
X#define P    PREANSI
X#define ANSI    4    /* combo not allowed anymore in ANSI compiler */
X#define A    ANSI
X
X/* This is an lower left triangular array. If we needed */
X/* to save 9 bytes, the "long" row can be removed. */
char crosscheck[9][9] = {
X    /*            L, I, S, C, V, U, S, F, D, */
X    /* long */        _, _, _, _, _, _, _, _, _,
X    /* int */        _, _, _, _, _, _, _, _, _,
X    /* short */        X, _, _, _, _, _, _, _, _,
X    /* char */        X, X, X, _, _, _, _, _, _,
X    /* void */        X, X, X, X, _, _, _, _, _,
X    /* unsigned */    R, _, R, R, X, _, _, _, _,
X    /* signed */    P, P, P, P, X, X, _, _, _,
X    /* float */        A, X, X, X, X, X, X, _, _,
X    /* double */    P, X, X, X, X, X, X, X, _
X};
X
X/* the names and bits checked for each row in the above array */
struct
X    {
X    char *name;
X    int bit;
X    } crosstypes[9] =
X    {
X        { "long",        MB_LONG        },
X        { "int",        MB_INT        },
X        { "short",        MB_SHORT    },
X        { "char",        MB_CHAR        },
X        { "void",        MB_VOID        },
X        { "unsigned",    MB_UNSIGNED    },
X        { "signed",        MB_SIGNED    },
X        { "float",        MB_FLOAT    },
X        { "double",        MB_DOUBLE    }
X    };
X
X/* Run through the crosscheck array looking */
X/* for unsupported combinations of types. */
void mbcheck()
X{
X    register int i, j, restrict;
X    char *t1, *t2;
X
X    /* Loop through the types */
X    /* (skip the "long" row) */
X    for (i = 1; i < 9; i++)
X    {
X    /* if this type is in use */
X    if ((modbits & crosstypes[i].bit) != 0)
X        {
X        /* check for other types also in use */
X        for (j = 0; j < i; j++)
X        {
X        /* this type is not in use */
X        if (!(modbits & crosstypes[j].bit))
X            continue;
X        /* check the type of restriction */
X        restrict = crosscheck[i][j];
X        if (restrict == ALWAYS)
X            continue;
X        t1 = crosstypes[i].name;
X        t2 = crosstypes[j].name;
X        if (restrict == NEVER)
X            {
X            notsupported("", t1, t2);
X            }
X        else if (restrict == RITCHIE)
X            {
X            if (RitchieFlag)
X            notsupported(" (Ritchie Compiler)", t1, t2);
X            }
X        else if (restrict == PREANSI)
X            {
X            if (PreANSIFlag || RitchieFlag)
X            notsupported(" (Pre-ANSI Compiler)", t1, t2);
X            }
X        else if (restrict == ANSI)
X            {
X            if (!RitchieFlag && !PreANSIFlag)
X            notsupported(" (ANSI Compiler)", t1, t2);
X            }
X        else
X            {
X            (void) fprintf (stderr,
X            "%s: Internal error in crosscheck[%d,%d]=%d!\n",
X            progname, i, j, restrict);
X            exit(1); /* NOTREACHED */
X            }
X        }
X        }
X    }
X}
X
X/* undefine these as they are no longer needed */
X#undef _
X#undef ALWAYS
X#undef X
X#undef NEVER
X#undef R
X#undef RITCHIE
X#undef P
X#undef PREANSI
X#undef A
X#undef ANSI
X
X/* Write out a message about something */
X/* being unsupported, possibly with a hint. */
void unsupp(s,hint)
char *s,*hint;
X{
X    notsupported("", s, NullCP);
X    if (hint)
X    (void) fprintf(stderr, "\t(maybe you mean \"%s\")\n", hint);
X}
X
X/* Write out a message about something */
X/* being unsupported on a particular compiler. */
void notsupported(compiler, type1, type2)
char *compiler, *type1, *type2;
X{
X    if (type2)
X    (void) fprintf(stderr,
X        "Warning: Unsupported in%s C%s -- '%s' with '%s'\n",
X        compiler, CplusplusFlag ? "++" : "", type1, type2);
X    else
X    (void) fprintf(stderr,
X        "Warning: Unsupported in%s C%s -- '%s'\n",
X        compiler, CplusplusFlag ? "++" : "", type1);
X}
X
X/* Called by the yacc grammar */
void yyerror(s)
char *s;
X{
X    (void) printf("%s\n",s);
X    Debug((stdout, "yychar=%d\n", yychar));
X}
X
X/* Called by the yacc grammar */
int yywrap()
X{
X    return 1;
X}
X
X/*
X * Support for dynamic strings:
X * cat() creates a string from the concatenation
X * of a null terminated list of input strings.
X * The input strings are free()'d by cat()
X * (so they better have been malloc()'d).
X *
X * the different methods of <stdarg.h> and
X * <vararg.h> are handled within these macros
X */
X#if __STDC__
X#  define VA_DCL(type,var)        (type var,...)
X#  define VA_START(list,var,type)    ((va_start(list,var)) , (var))
X#else
X#if defined(DOS)
X#  define VA_DCL(type,var)        (var,...) type var;
X#  define VA_START(list,var,type)    ((va_start(list,var)) , (var))
X#else
X#ifndef NOVARARGS
X# define VA_DCL(type,var)        (va_alist) va_dcl
X# define VA_START(list,var,type)    ((va_start(list)) , va_arg(list,type))
X#else
X   /*
X    *    it is assumed here that machines which don't have either
X    *    <varargs.h> or <stdarg.h> will put its arguments on
X    *    the stack in the "usual" way and consequently can grab
X    *    the arguments using the "take the address of the first
X    *    parameter and increment by sizeof" trick.
X    */
X# define VA_DCL(type,var)        (var) type var;
X# define VA_START(list,var,type)    (list = (va_list)&(var) , (var))
X# define va_arg(list,type)        ((type *)(list += sizeof(type)))[-1]
X# define va_end(p)            /* nothing */
typedef char *va_list;
X#endif /* NOVARARGS */
X#endif /* DOS */
X#endif /* __STDC__ */
X
X/* VARARGS */
char *cat
VA_DCL(char*, s1)
X{
X    register char *newstr;
X    register unsigned len = 1;
X    char *str;
X    va_list args;
X
X    /* find the length which needs to be allocated */
X    str = VA_START(args, s1, char*);
X    for ( ; str; str = va_arg(args, char*))
X    len += strlen(str);
X    va_end(args);
X
X    /* allocate it */
X    newstr = malloc(len);
X    if (newstr == 0)
X    {
X    (void) fprintf (stderr, "%s: out of malloc space within cat()!\n",
X        progname);
X    exit(1);
X    }
X    newstr[0] = '\0';
X
X    /* copy in the strings */
X    str = VA_START(args, s1, char*);
X    for ( ; str; str = va_arg(args, char*))
X    {
X    (void) strcat(newstr,str);
X    free(str);
X    }
X    va_end(args);
X
X    Debug((stderr, "\tcat created '%s'\n", newstr));
X    return newstr;
X}
X
X/*
X * ds() makes a malloc()'d string from one that's not.
X */
char *ds(s)
char *s;
X{
X    register char *p = malloc((unsigned)(strlen(s)+1));
X
X    if (p)
X    (void) strcpy(p,s);
X    else
X    {
X    (void) fprintf (stderr, "%s: malloc() failed!\n", progname);
X    exit(1);
X    }
X    return p;
X}
X
X/* return a visible representation of a character */
char *visible(c)
int c;
X{
X    static char buf[5];
X
X    c &= 0377;
X    if (isprint(c))
X    {
X    buf[0] = c;
X    buf[1] = '\0';
X    }
X    else
X    (void) sprintf(buf,"\\%03o",c);
X    return buf;
X}
X
X#ifdef NOTMPFILE
X/* provide a conservative version of tmpfile() */
X/* for those systems without it. */
X/* tmpfile() returns a FILE* of a file opened */
X/* for read&write. It is supposed to be */
X/* automatically removed when it gets closed, */
X/* but here we provide a separate rmtmpfile() */
X/* function to perform that function. */
X/* Also provide several possible file names to */
X/* try for opening. */
static char *file4tmpfile = 0;
X
XFILE *tmpfile()
X{
X    static char *listtmpfiles[] =
X    {
X    "/usr/tmp/cdeclXXXXXX",
X    "/tmp/cdeclXXXXXX",
X    "/cdeclXXXXXX",
X    "cdeclXXXXXX",
X    0
X    };
X
X    char **listp = listtmpfiles;
X    for ( ; *listp; listp++)
X    {
X    FILE *retfp;
X    (void) mktemp(*listp);
X    retfp = fopen(*listp, "w+");
X    if (!retfp)
X        continue;
X    file4tmpfile = *listp;
X    return retfp;
X    }
X
X    return 0;
X}
X
void rmtmpfile()
X{
X    if (file4tmpfile)
X    (void) unlink(file4tmpfile);
X}
X#else
X/* provide a mock rmtmpfile() for normal systems */
X# define rmtmpfile()    /* nothing */
X#endif /* NOTMPFILE */
X
X#ifndef NOGETOPT
extern int optind;
X#else
X/* This is a miniature version of getopt() which will */
X/* do just barely enough for us to get by below. */
X/* Options are not allowed to be bunched up together. */
X/* Option arguments are not supported. */
int optind = 1;
X
int getopt(argc,argv,optstring)
char **argv;
char *optstring;
X{
X    int ret;
X    char *p;
X
X    if ((argv[optind][0] != '-')
X#ifdef DOS
X    && (argv[optind][0] != '/')
X#endif /* DOS */
X    )
X    return EOF;
X
X    ret = argv[optind][1];
X    optind++;
X
X    for (p = optstring; *p; p++)
X    if (*p == ret)
X        return ret;
X
X    (void) fprintf (stderr, "%s: illegal option -- %s\n",
X    progname, visible(ret));
X
X    return '?';
X}
X#endif
X
X/* the help messages */
struct helpstruct
X    {
X    char *text;    /* generic text */
X    char *cpptext;    /* C++ specific text */
X    } helptext[] =
X    {    /* up-to 23 lines of help text so it fits on (24x80) screens */
X/*  1 */{ "[] means optional; {} means 1 or more; <> means defined elsewhere", 0 },
X/*  2 */{ "  commands are separated by ';' and newlines", 0 },
X/*  3 */{ "command:", 0 },
X/*  4 */{ "  declare <name> as <english>", 0 },
X/*  5 */{ "  cast <name> into <english>", 0 },
X/*  6 */{ "  explain <gibberish>", 0 },
X/*  7 */{ "  set or set options", 0 },
X/*  8 */{ "  help, ?", 0 },
X/*  9 */{ "  quit or exit", 0 },
X/* 10 */{ "english:", 0 },
X/* 11 */{ "  function [( <decl-list> )] returning <english>", 0 },
X/* 12 */{ "  array [<number>] of <english>", 0 },
X/* 13 */{ "  [{ const | volatile | noalias }] pointer to <english>",
X      "  [{const|volatile}] {pointer|reference} to [member of class <name>] <english>" },
X/* 14 */{ "  <type>", 0 },
X/* 15 */{ "type:", 0 },
X/* 16 */{ "  {[<storage-class>] [{<modifier>}] [<C-type>]}", 0 },
X/* 17 */{ "  { struct | union | enum } <name>",
X      "  {struct|class|union|enum} <name>" },
X/* 18 */{ "decllist: a comma separated list of <name>, <english> or <name> as <english>", 0 },
X/* 19 */{ "name: a C identifier", 0 },
X/* 20 */{ "gibberish: a C declaration, like 'int *x', or cast, like '(int *)x'", 0 },
X/* 21 */{ "storage-class: extern, static, auto, register", 0 },
X/* 22 */{ "C-type: int, char, float, double, or void", 0 },
X/* 23 */{ "modifier: short, long, signed, unsigned, const, volatile, or noalias",
X      "modifier: short, long, signed, unsigned, const, or volatile" },
X    { 0, 0 }
X    };
X
X/* Print out the help text */
void dohelp()
X{
X    register struct helpstruct *p;
X    register char *fmt = CplusplusFlag ? " %s\n" : "\t%s\n";
X
X    for (p = helptext; p->text; p++)
X    if (CplusplusFlag && p->cpptext)
X        (void) printf(fmt, p->cpptext);
X    else
X        (void) printf(fmt, p->text);
X}
X
X/* Tell how to invoke cdecl. */
void usage()
X{
X    (void) fprintf (stderr, "Usage: %s [-r|-p|-a|-+] [-ci%s%s] [files...]\n",
X    progname,
X#ifdef dodebug
X    "d",
X#else
X    "",
X#endif /* dodebug */
X#ifdef doyydebug
X    "D"
X#else
X    ""
X#endif /* doyydebug */
X    );
X    (void) fprintf (stderr, "\t-r Check against Ritchie PDP C Compiler\n");
X    (void) fprintf (stderr, "\t-p Check against Pre-ANSI C Compiler\n");
X    (void) fprintf (stderr, "\t-a Check against ANSI C Compiler%s\n",
X    CplusplusFlag ? "" : " (the default)");
X    (void) fprintf (stderr, "\t-+ Check against C++ Compiler%s\n",
X    CplusplusFlag ? " (the default)" : "");
X    (void) fprintf (stderr, "\t-c Create compilable output (include ; and {})\n");
X    (void) fprintf (stderr, "\t-i Force interactive mode\n");
X#ifdef dodebug
X    (void) fprintf (stderr, "\t-d Turn on debugging mode\n");
X#endif /* dodebug */
X#ifdef doyydebug
X    (void) fprintf (stderr, "\t-D Turn on YACC debugging mode\n");
X#endif /* doyydebug */
X    exit(1);
X    /* NOTREACHED */
X}
X
X/* Manage the prompts. */
static int prompting = 1;
X
void doprompt() { prompting = 1; }
void noprompt() { prompting = 0; }
X
void prompt()
X{
X    if ((OnATty || Interactive) && prompting) {
X    (void) printf("%s> ", progname);
X    (void) fflush(stdout);
X    }
X}
X
X/* Save away the name of the program from argv[0] */
void setprogname(argv0)
char *argv0;
X{
X#ifdef DOS
X    char *dot;
X#endif /* DOS */
X
X    progname = strrchr(argv0, '/');
X
X#ifdef DOS
X    if (!progname)
X    progname = strrchr(argv0, '\\');
X#endif /* DOS */
X
X    if (progname)
X    progname++;
X    else
X    progname = argv0;
X
X#ifdef DOS
X    dot = strchr(progname, '.');
X    if (dot)
X    *dot = '\0';
X    for (dot = progname; *dot; dot++)
X    *dot = tolower(*dot);
X#endif /* DOS */
X}
X
X/* Run down the list of keywords to see if the */
X/* program is being called named as one of them */
X/* or the first argument is one of them. */
int namedkeyword(argn)
char *argn;
X{
X    static char *cmdlist[] =
X    {
X    "explain", "declare", "cast", "help", "?", "set", 0
X    };
X
X    /* first check the program name */
X    char **cmdptr = cmdlist;
X    for ( ; *cmdptr; cmdptr++)
X    if (strcmp(*cmdptr, progname) == 0)
X        {
X        KeywordName = 1;
X        return 1;
X        }
X
X    /* now check $1 */
X    for (cmdptr = cmdlist; *cmdptr; cmdptr++)
X    if (strcmp(*cmdptr, argn) == 0)
X        return 1;
X
X    /* nope, must be file name arguments */
X    return 0;
X}
X
X/* Read from standard input, turning */
X/* on prompting if necessary. */
int dostdin()
X{
X    int ret;
X    OnATty = isatty(0);
X    if (OnATty || Interactive)
X    {
X    (void) printf("Type `help' or `?' for help\n");
X    prompt();
X    }
X
X    yyin = stdin;
X    ret = yyparse();
X    OnATty = 0;
X    return ret;
X}
X
X/* Write the arguments into a file */
X/* and treat that file as the input. */
int dotmpfile(argc, argv)
int argc;
char **argv;
X{
X    int ret = 0;
X    FILE *tmpfp = tmpfile();
X    if (!tmpfp)
X    {
X    int sverrno = errno;
X    (void) fprintf (stderr, "%s: cannot open temp file\n",
X        progname);
X    errno = sverrno;
X    perror(progname);
X    return 1;
X    }
X
X    if (KeywordName)
X    if (fputs(progname, tmpfp) == EOF)
X        {
X        int sverrno;
X    errwrite:
X        sverrno = errno;
X        (void) fprintf (stderr, "%s: error writing to temp file\n",
X        progname);
X        errno = sverrno;
X        perror(progname);
X        (void) fclose(tmpfp);
X        rmtmpfile();
X        return 1;
X        }
X
X    for ( ; optind < argc; optind++)
X    if (fprintf(tmpfp, " %s", argv[optind]) == EOF)
X        goto errwrite;
X
X    if (putc('\n', tmpfp) == EOF)
X    goto errwrite;
X
X    rewind(tmpfp);
X    yyin = tmpfp;
X    ret += yyparse();
X    (void) fclose(tmpfp);
X    rmtmpfile();
X
X    return ret;
X}
X
X/* Read each of the named files for input. */
int dofileargs(argc, argv)
int argc;
char **argv;
X{
X    FILE *ifp;
X    int ret = 0;
X
X    for ( ; optind < argc; optind++)
X    if (strcmp(argv[optind], "-") == 0)
X        ret += dostdin();
X
X    else if ((ifp = fopen(argv[optind], "r")) == NULL)
X        {
X        int sverrno = errno;
X        (void) fprintf (stderr, "%s: cannot open %s\n",
X        progname, argv[optind]);
X        errno = sverrno;
X        perror(argv[optind]);
X        ret++;
X        }
X
X    else
X        {
X        yyin = ifp;
X        ret += yyparse();
X        }
X
X    return ret;
X}
X
X/* print out a cast */
void docast(name, left, right, type)
char *name, *left, *right, *type;
X{
X    int lenl = strlen(left), lenr = strlen(right);
X
X    if (prev == 'f')
X        unsupp("Cast into function",
X            "cast into pointer to function");
X    else if (prev=='A' || prev=='a')
X        unsupp("Cast into array","cast into pointer");
X    (void) printf("(%s%*s%s)%s\n",
X        type, lenl+lenr?lenl+1:0,
X        left, right, name ? name : "expression");
X    free(left);
X    free(right);
X    free(type);
X    if (name)
X        free(name);
X}
X
X/* print out a declaration */
void dodeclare(name, storage, left, right, type)
char *name, *storage, *left, *right, *type;
X{
X    if (prev == 'v')
X        unsupp("Variable of type void",
X            "variable of type pointer to void");
X
X    if (*storage == 'r')
X    switch (prev)
X        {
X        case 'f': unsupp("Register function", NullCP); break;
X        case 'A':
X        case 'a': unsupp("Register array", NullCP); break;
X        case 's': unsupp("Register struct/class", NullCP); break;
X        }
X
X    if (*storage)
X        (void) printf("%s ", storage);
X    (void) printf("%s %s%s%s",
X        type, left,
X    name ? name : (prev == 'f') ? "f" : "var", right);
X    if (MkProgramFlag) {
X        if ((prev == 'f') && (*storage != 'e'))
X            (void) printf(" { }\n");
X        else
X            (void) printf(";\n");
X    } else {
X        (void) printf("\n");
X    }
X    free(storage);
X    free(left);
X    free(right);
X    free(type);
X    if (name)
X        free(name);
X}
X
void dodexplain(storage, constvol, type, decl)
char *storage, *constvol, *type, *decl;
X{
X    if (type && (strcmp(type, "void") == 0))
X    if (prev == 'n')
X        unsupp("Variable of type void",
X           "variable of type pointer to void");
X    else if (prev == 'a')
X        unsupp("array of type void",
X           "array of type pointer to void");
X    else if (prev == 'r')
X        unsupp("reference to type void",
X           "pointer to void");
X
X    if (*storage == 'r')
X    switch (prev)
X        {
X        case 'f': unsupp("Register function", NullCP); break;
X        case 'A':
X        case 'a': unsupp("Register array", NullCP); break;
X        case 's': unsupp("Register struct/union/enum/class", NullCP); break;
X        }
X
X    (void) printf("declare %s as ", savedname);
X    if (*storage)
X        (void) printf("%s ", storage);
X    (void) printf("%s", decl);
X    if (*constvol)
X        (void) printf("%s ", constvol);
X    (void) printf("%s\n", type ? type : "int");
X}
X
void docexplain(constvol, type, cast, name)
char *constvol, *type, *cast, *name;
X{
X    if (strcmp(type, "void") == 0)
X    if (prev == 'a')
X        unsupp("array of type void",
X           "array of type pointer to void");
X    else if (prev == 'r')
X        unsupp("reference to type void",
X           "pointer to void");
X    (void) printf("cast %s into %s", name, cast);
X    if (strlen(constvol) > 0)
X        (void) printf("%s ", constvol);
X    (void) printf("%s\n",type);
X}
X
X/* Do the appropriate things for the "set" command. */
void doset(opt)
char *opt;
X{
X    if (strcmp(opt, "create") == 0)
X    { MkProgramFlag = 1; }
X    else if (strcmp(opt, "nocreate") == 0)
X    { MkProgramFlag = 0; }
X    else if (strcmp(opt, "interactive") == 0)
X    { Interactive = 1; }
X    else if (strcmp(opt, "nointeractive") == 0)
X    { Interactive = 0; OnATty = 0; }
X    else if (strcmp(opt, "ritchie") == 0)
X    { CplusplusFlag=0; RitchieFlag=1; PreANSIFlag=0; }
X    else if (strcmp(opt, "preansi") == 0)
X    { CplusplusFlag=0; RitchieFlag=0; PreANSIFlag=1; }
X    else if (strcmp(opt, "ansi") == 0)
X    { CplusplusFlag=0; RitchieFlag=0; PreANSIFlag=0; }
X    else if (strcmp(opt, "cplusplus") == 0)
X    { CplusplusFlag=1; RitchieFlag=0; PreANSIFlag=0; }
X#ifdef dodebug
X    else if (strcmp(opt, "debug") == 0)
X    { DebugFlag = 1; }
X    else if (strcmp(opt, "nodebug") == 0)
X    { DebugFlag = 0; }
X#endif /* dodebug */
X#ifdef doyydebug
X    else if (strcmp(opt, "yydebug") == 0)
X    { yydebug = 1; }
X    else if (strcmp(opt, "noyydebug") == 0)
X    { yydebug = 0; }
X#endif /* doyydebug */
X    else
X    {
X    if ((strcmp(opt, unknown_name) != 0) &&
X        (strcmp(opt, "options") != 0))
X        (void) printf("Unknown set option: '%s'\n", opt);
X
X    (void) printf("Valid set options (and command line equivalents) are:\n");
X    (void) printf("\toptions\n");
X    (void) printf("\tcreate (-c), nocreate\n");
X    (void) printf("\tinteractive (-i), nointeractive\n");
X    (void) printf("\tritchie (-r), preansi (-p), ansi (-a) or cplusplus (-+)\n");
X#ifdef dodebug
X    (void) printf("\tdebug (-d), nodebug\n");
X#endif /* dodebug */
X#ifdef doyydebug
X    (void) printf("\tyydebug (-D), noyydebug\n");
X#endif /* doyydebug */
X
X    (void) printf("\nCurrent set values are:\n");
X    (void) printf("\t%screate\n", MkProgramFlag ? "   " : " no");
X    (void) printf("\t%sinteractive\n",
X        (OnATty || Interactive) ? "   " : " no");
X    if (RitchieFlag)
X        (void) printf("\t   ritchie\n");
X    else
X        (void) printf("\t(noritchie)\n");
X    if (PreANSIFlag)
X        (void) printf("\t   preansi\n");
X    else
X        (void) printf("\t(nopreansi)\n");
X    if (!RitchieFlag && !PreANSIFlag && !CplusplusFlag)
X        (void) printf("\t   ansi\n");
X    else
X        (void) printf("\t(noansi)\n");
X    if (CplusplusFlag)
X        (void) printf("\t   cplusplus\n");
X    else
X        (void) printf("\t(nocplusplus)\n");
X#ifdef dodebug
X    (void) printf("\t%sdebug\n", DebugFlag ? "   " : " no");
X#endif /* dodebug */
X#ifdef doyydebug
X    (void) printf("\t%syydebug\n", yydebug ? "   " : " no");
X#endif /* doyydebug */
X    }
X}
X
void versions()
X{
X    (void) printf("Version:\n\t%s\n\t%s\n\t%s\n",
X    cdeclsccsid, cdgramsccsid, cdlexsccsid);
X    exit(0);
X}
X
int main(argc, argv)
char **argv;
X{
X    int c, ret = 0;
X
X    setprogname(argv[0]);
X#ifdef DOS
X    if (strcmp(progname, "cppdecl") == 0)
X#else
X    if (strcmp(progname, "c++decl") == 0)
X#endif /* DOS */
X    CplusplusFlag = 1;
X
X    while ((c = getopt(argc, argv, "cirpa+dDV")) != EOF)
X    switch (c)
X        {
X        case 'c': MkProgramFlag=1; break;
X        case 'i': Interactive=1; break;
X
X        /* The following are mutually exclusive. */
X        /* Only the last one set prevails. */
X        case 'r': CplusplusFlag=0; RitchieFlag=1; PreANSIFlag=0; break;
X        case 'p': CplusplusFlag=0; RitchieFlag=0; PreANSIFlag=1; break;
X        case 'a': CplusplusFlag=0; RitchieFlag=0; PreANSIFlag=0; break;
X        case '+': CplusplusFlag=1; RitchieFlag=0; PreANSIFlag=0; break;
X
X#ifdef dodebug
X        case 'd': DebugFlag=1; break;
X#endif /* dodebug */
X#ifdef doyydebug
X        case 'D': yydebug=1; break;
X#endif /* doyydebug */
X        case 'V': versions(); break;
X        case '?': usage(); break;
X        }
X
X    /* Run down the list of arguments, parsing each one. */
X
X    /* Use standard input if no file names or "-" is found. */
X    if (optind == argc)
X    ret += dostdin();
X
X    /* If called as explain, declare or cast, or first */
X    /* argument is one of those, use the command line */
X    /* as the input. */
X    else if (namedkeyword(argv[optind]))
X    ret += dotmpfile(argc, argv);
X
X    else
X    ret += dofileargs(argc, argv);
X
X    exit(ret);
X    /* NOTREACHED */
X}
END_OF_FILE
if test 25555 -ne `wc -c <'cdecl.c'`; then
    echo shar: \"'cdecl.c'\" unpacked with wrong size!
fi
# end of 'cdecl.c'
fi
echo shar: End of archive 2 \(of 2\).
cp /dev/null ark2isdone
MISSING=""
for I in 1 2 ; do
    if test ! -f ark${I}isdone ; then
    MISSING="${MISSING} ${I}"
    fi
done
if test "${MISSING}" = "" ; then
    echo You have unpacked both archives.
    rm -f ark[1-9]isdone
else
    echo You still need to unpack the following archives:
    echo "        " ${MISSING}
fi
##  End of shell archive.
exit 0